// 工具函数和API接口封装
import axios from "axios";

// 创建axios实例
const api = axios.create({
  timeout: 10000, // 请求超时时间
  headers: {
    "Content-Type": "application/json",
  },
});

// 请求拦截器
api.interceptors.request.use(
  (config) => {
    // 在发送请求之前做些什么
    return config;
  },
  (error) => {
    // 对请求错误做些什么
    return Promise.reject(error);
  }
);

// 响应拦截器
api.interceptors.response.use(
  (response) => {
    // 对响应数据做点什么
    return response;
  },
  (error) => {
    // 对响应错误做点什么
    console.error("API请求错误:", error);
    return Promise.reject(error);
  }
);

/**
 * 登录接口
 * @param {Object} params - 登录参数
 * @param {string} params.account - 账号
 * @param {string} params.password - 密码
 * @returns {Promise} - 返回登录结果
 */
export const login = async ({ account, password }) => {
  try {
    const response = await request("/api/login", {
      method: "POST",
      data: { account, password },
    });

    // 确保返回的数据结构符合user store的期望
    return {
      code: response.code || 100,
      message: response.message || "登录成功",
      data: response.data || response,
    };
  } catch (error) {
    console.error("登录请求错误:", error);
    throw error;
  }
};

/**
 * 验证登录状态接口
 * @returns {Promise<Object>} - 返回登录状态信息
 */
export const verifyLogin = async () => {
  try {
    const response = await request("/api/verifyLogin");

    // 确保返回的数据结构符合路由守卫的期望
    return {
      code: response.code || 100,
      message: response.message || "验证成功",
      data: response.data || response,
    };
  } catch (error) {
    console.error("验证登录状态错误:", error);
    // 返回null或抛出错误表示未登录
    if (error.response && error.response.status === 401) {
      return null;
    }
    return null;
  }
};

/**
 * 通用请求函数
 * @param {string} url - 请求地址
 * @param {Object} options - 请求选项
 * @returns {Promise} - 返回请求结果
 */
export const request = async (url, options = {}) => {
  try {
    // 自动添加/api前缀，除非url已经是完整的URL或已经包含/api
    let apiUrl = url;
    const isExternalUrl =
      url.startsWith("http://") || url.startsWith("https://");

    // if (!isExternalUrl && !url.startsWith("/api")) {
    //   apiUrl = `/api${url.startsWith("/") ? "" : "/"}${url}`;
    // }

    // 设置默认选项
    const defaultOptions = {
      method: "GET",
      withCredentials: !isExternalUrl, // 外部API默认不包含凭证
    };

    const mergedOptions = {
      ...defaultOptions,
      ...options,
      url: apiUrl,
    };

    // 使用axios发送请求
    let response;
    if (isExternalUrl) {
      // 对于外部API，创建一个新的axios实例
      const externalApi = axios.create({
        timeout: 10000,
        headers: {
          "Content-Type": "application/json",
        },
      });
      response = await externalApi(mergedOptions);
    } else {
      // 内部API使用共享的axios实例
      response = await api(mergedOptions);
    }

    // 检查响应内容类型
    const contentType = response.headers["content-type"];
    if (contentType && contentType.includes("application/json")) {
      return response.data;
    }

    return response.data;
  } catch (error) {
    console.error(`请求${url}错误:`, error);
    throw error;
  }
};

/**
 * 获取完全控制状态接口
 * @param {string} userId - 用户ID
 * @param {number} plantId - 设备ID，默认为68
 * @param {number} timeSlice - 时间切片，默认为10000，用来向后端减少自身的剩余控制时间
 * @returns {Promise<Object>} - 返回控制状态信息
 */
export const getFullControlStatus = async (
  userId,
  plantId = 68,
  timeSlice = 10000
) => {
  try {
    // 参数验证
    if (!userId || (typeof userId !== "string" && typeof userId !== "number")) {
      throw new Error("用户ID不能为空且必须是字符串或数字");
    }

    // 构建URL
    const url = `/api/getFullControlStatus/${userId}/${plantId}/${timeSlice}`;

    // 使用通用request函数发送请求
    const response = await request(url, {
      method: "GET",
    });

    // 处理返回数据
    let result = {
      code: response.code || 100,
      message: response.message || "获取状态成功",
      data: response.data || response,
    };

    // 如果有queueInfo和plantInfo，解析currentUsers数组，找到用户ID的位置
    if (response.queueInfo && response.queueInfo.plantInfo) {
      const plantInfo = response.queueInfo.plantInfo;

      // 解析currentUsers数组，找到用户ID的位置
      if (plantInfo.currentUsers) {
        let currentUsersArray;

        // 处理currentUsers字段（可能是字符串或数组）
        if (typeof plantInfo.currentUsers === "string") {
          try {
            currentUsersArray = JSON.parse(plantInfo.currentUsers);
          } catch (e) {
            console.error("解析currentUsers字符串失败:", e);
            currentUsersArray = [];
          }
        } else if (Array.isArray(plantInfo.currentUsers)) {
          currentUsersArray = plantInfo.currentUsers;
        } else {
          currentUsersArray = [];
        }

        // 查找用户ID在数组中的位置
        const userIndex = currentUsersArray.findIndex(
          (user) => user === parseInt(userId)
        );

        if (userIndex !== -1) {
          result.copyNum = userIndex;
          // console.log(
          //   `用户ID ${userId} 在currentUsers数组中的位置: ${userIndex}`
          // );
        }
      }

      // 处理userList
      if (
        response.queueInfo.userList &&
        Array.isArray(response.queueInfo.userList)
      ) {
        if (response.queueInfo.userList.length === 0) {
          // 如果userList为空，触发requestFullControl接口
          console.log("userList为空，触发requestFullControl接口");
          try {
            const controlResponse = await requestFullControl(userId);
            result.controlResponse = controlResponse;
          } catch (error) {
            console.error("调用requestFullControl接口失败:", error);
          }
        } else {
          // 如果userList不为空，保存第一个元素的copyNum和timeLeft
          const firstUser = response.queueInfo.userList[0];
          result.firstUserInfo = {
            copyNum: firstUser.copyNum,
            timeLeft: firstUser.timeLeft,
            userId: firstUser.userId,
            name: firstUser.name,
          };
          result.copyNum = firstUser.copyNum;
          // console.log(
          //   `userList不为空，第一个用户的copyNum: ${firstUser.copyNum}, timeLeft: ${firstUser.timeLeft}`
          // );
        }
      }
    }

    return result;
  } catch (error) {
    console.error("获取完全控制状态错误:", error);
    throw error;
  }
};

/**
 * 请求完全控制接口
 * @param {string} userId - 用户ID，将从user store中获取
 * @returns {Promise<Object>} - 返回请求结果
 */
export const requestFullControl = async (userId) => {
  try {
    // 参数验证
    if (!userId || (typeof userId !== "string" && typeof userId !== "number")) {
      throw new Error("用户ID不能为空且必须是字符串或数字");
    }

    // 构建URL，动态填充用户ID
    const url = `/api/requestFullControl/${userId}/68`;

    // 使用通用request函数发送请求
    const response = await request(url, {
      method: "GET",
    });

    // 确保返回的数据结构符合项目标准，与其他接口保持一致
    return {
      code: response.code || 100,
      message: response.message || "请求成功",
      data: response.data || response,
    };
  } catch (error) {
    console.error("请求完全控制错误:", error);
    throw error;
  }
};

/**
 * 设置算法参数接口
 * @param {string} pos - 参数位置，例如"2_6_0_0"
 * @param {number|string} value - 参数值，例如2.5
 * @param {number} plantId - 设备ID，默认为68
 * @param {number} plantType - 设备类型，默认为1
 * @param {number} copyNum - 副本数量，默认为5
 * @returns {Promise<Object>} - 返回设置结果
 */
export const setAlgorithmParam = async (
  pos,
  value,
  copyNum = 5,
  plantId = 68,
  plantType = 1
) => {
  try {
    // 参数验证
    if (!pos || typeof pos !== "string") {
      throw new Error("参数位置不能为空且必须是字符串");
    }
    if (value === undefined || value === null) {
      throw new Error("参数值不能为空");
    }

    // 构建完整的外部API URL
    const url = `/rtlab/ExperimentServlet`;

    // 使用通用request函数发送GET请求
    const response = await request(url, {
      method: "GET",
      params: {
        method: "setParam",
        plantId,
        pos,
        value,
        plantType,
        copyNum,
      },
    });

    // 确保返回的数据结构符合项目标准
    return {
      code: response.code || 100,
      message: response.message || "设置参数成功",
      data: response.data || response,
    };
  } catch (error) {
    console.error("设置算法参数错误:", error);
    throw error;
  }
};
